home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / lalr.lha / lalr / src / ArgCheck.mi < prev    next >
Text File  |  1992-08-18  |  10KB  |  384 lines
  1. (* check arguments *)
  2.  
  3. (* $Id: ArgCheck.mi,v 2.4 1992/08/07 15:22:49 grosch rel $ *)
  4.  
  5. (* $Log: ArgCheck.mi,v $
  6.  * Revision 2.4  1992/08/07  15:22:49  grosch
  7.  * allow several scanner and parsers; extend module Errors
  8.  *
  9.  * Revision 2.3  1992/01/30  14:08:30  grosch
  10.  * redesign of interface to operating system
  11.  *
  12.  * Revision 2.2  1991/11/21  14:53:14  grosch
  13.  * new version of RCS on SPARC
  14.  *
  15.  * Revision 2.1  91/10/09  09:05:14  grosch
  16.  * renamed NULL in DevNull for C compatibility
  17.  * 
  18.  * Revision 2.0  91/03/08  18:31:31  grosch
  19.  * turned tables into initialized arrays (in C)
  20.  * moved mapping tokens -> strings from Errors to Parser
  21.  * changed interface for source position
  22.  * 
  23.  * Revision 1.5  90/06/12  16:53:33  grosch
  24.  * renamed main program to lalr, added { } for actions, layout improvements
  25.  * 
  26.  * Revision 1.4     89/10/18  19:41:33  grosch
  27.  * renamed ScanTab and ParsTab to Scan.Tab and Pars.Tab because of PCTE
  28.  * 
  29.  * Revision 1.3     89/05/02  14:33:06  vielsack
  30.  * new option: -v
  31.  * 
  32.  * Revision 1.2     89/02/24  14:06:52  vielsack
  33.  * call BeginFile
  34.  * 
  35.  * Revision 1.1     89/01/12  18:10:34  vielsack
  36.  * supply source file name
  37.  * 
  38.  * Revision 1.0     88/10/04  14:35:47  vielsack
  39.  * Initial revision
  40.  * 
  41.  *)
  42.  
  43. IMPLEMENTATION MODULE ArgCheck;
  44.  
  45. FROM Actions    IMPORT    ScannerName,    ParserName;
  46. FROM Character    IMPORT    IsEqual,    Assign;
  47. FROM Check    IMPORT    Verbose;
  48. FROM Checks    IMPORT    CheckReadOpen,    CheckWriteOpen;
  49. FROM Debug    IMPORT    NoTrace;
  50. FROM Default    IMPORT    NoDefault;
  51. FROM Errors    IMPORT    eError,        eString,
  52.             ErrorMessageI,    tReportMode,    SetReportMode,
  53.             CloseErrors;
  54. FROM Gen    IMPORT    CaseFlag,    CaseLabels;
  55. FROM Idents    IMPORT    tIdent, NoIdent, WriteIdent, GetString;
  56. FROM IO        IMPORT    tFile,        StdInput,    StdOutput,
  57.             ReadOpen,    WriteOpen,    ReadClose,
  58.             WriteClose,    EndOfFile,    CloseIO,
  59.             WriteS,        WriteC,        WriteNl;
  60. FROM Listing    IMPORT    SourceFile;
  61. FROM Path    IMPORT    InsertPath;
  62. FROM Parser    IMPORT    ParsTabName;
  63. FROM Scanner    IMPORT    ScanTabName,    BeginFile;
  64. FROM Positions    IMPORT    NoPosition;
  65. FROM Strings    IMPORT    tString,    tStringIndex,    ArrayToString,
  66.             StringToArray,    SubString,    Char,
  67.             Concatenate,    Length,     ReadL,
  68.             WriteL,        StringToInt,    Append;
  69. FROM SysError    IMPORT    StatIsBad,    SysErrorMessageI;
  70. FROM System    IMPORT    GetArgument,    GetArgCount;
  71. FROM SYSTEM    IMPORT    ADR;
  72. FROM WriteTok    IMPORT    tLanguage,    Language,    SourceFileName;
  73.  
  74. CONST
  75.   eToManyArgs    = 21;
  76.   eNoOption    = 20;
  77.  
  78.   DevNull    = '/dev/null';
  79.   Drv        = 'Drv';
  80.   ExtDefM    = '.md';
  81.   ExtImpM    = '.mi';
  82.   ExtDefC    = '.h';
  83.   ExtImpC    = '.c';
  84.  
  85.   ScanDefM    = 'Scanner.md';
  86.   ScanImpM    = 'Scanner.mi';
  87.   ErrDefM    = 'Errors.md';
  88.   ErrImpM    = 'Errors.mi';
  89.   ParsDefM    = 'Parser.md';
  90.   ParsImpM    = 'Parser.mi';
  91.   ParsDrvM    = 'ParserDrv.mi';
  92.  
  93.   ScanDefC    = 'Scanner.h';
  94.   ScanImpC    = 'Scanner.c';
  95.   ErrDefC    = 'Errors.h';
  96.   ErrImpC    = 'Errors.c';
  97.   ParsDefC    = 'Parser.h';
  98.   ParsImpC    = 'Parser.c';
  99.   ParsDrvC    = 'ParserDrv.c';
  100.  
  101.   HelpFile    = 'lalr.cat';
  102.   ShortHelpFile = 'lalr.syn';
  103.  
  104.   cHelp        = '-h';
  105.   cC        = '-c';
  106.   cModula    = '-m';
  107.   cDefinition    = '-d';
  108.   cErrors    = '-e';
  109.   cLong        = '-l';
  110.   cImmediate    = '-i';
  111.   cScan        = '-s';
  112.   cParsDrv    = '-p';
  113.   cAll        = '-a';
  114.   cCase        = '-cs';
  115.   cVerbose    = '-v';
  116.   cLine        = '-g';
  117.   cNoTrace    = '-NoTrace';
  118.   cNoDefault    = '-NoDefault';
  119.   cTest        = '-t';
  120.  
  121. VAR MakeDef, MakeErr, MakeScan, MakeParsDrv: BOOLEAN;
  122.  
  123. PROCEDURE ArgCheck;
  124.   VAR
  125.     ArgNo        : CARDINAL;
  126.     Argument        : ARRAY [0..255] OF CHAR;
  127.     ArgString        : tString;
  128.     file        : tFile;
  129.     FileName        : ARRAY [0..255] OF CHAR;
  130.     SourceFileIsOpen    : BOOLEAN;
  131.   BEGIN
  132.     SourceFileIsOpen := FALSE;
  133.     InsertPath (ScanTabName);
  134.     InsertPath (ParsTabName);
  135.  
  136.     MakeDef := FALSE;
  137.     MakeErr := FALSE;
  138.     MakeScan := FALSE;
  139.     MakeParsDrv := FALSE;
  140.  
  141.     FOR ArgNo := 1 TO GetArgCount () - 1 DO
  142.       GetArgument (ArgNo, Argument);
  143.       IF (Argument [0] >= '0') & (Argument [0] <= '9') THEN
  144.     ArrayToString (Argument, ArgString);
  145.     CaseLabels := StringToInt (ArgString);
  146.     CaseFlag := TRUE;
  147.       ELSIF Argument [0] # '-' THEN
  148.     IF SourceFileIsOpen THEN
  149.       ArrayToString (Argument, ArgString);
  150.       ErrorMessageI (eToManyArgs, eError, NoPosition, eString, ADR (ArgString));
  151.     ELSE
  152.       Assign (SourceFileName, Argument);
  153.       SourceFile := ReadOpen (Argument);
  154.       IF StatIsBad (SourceFile) THEN
  155.         ArrayToString (Argument, ArgString);
  156.         SysErrorMessageI (SourceFile, eError, eString, ADR(ArgString));
  157.         SourceFile := StdInput;
  158.       ELSE
  159.         SourceFileIsOpen := TRUE;
  160.         BeginFile (Argument);
  161.       END;
  162.     END;
  163.       
  164.       ELSIF IsEqual (Argument, cC) THEN
  165.     Language := C;
  166.       ELSIF IsEqual (Argument, cModula) THEN
  167.     Language := Modula2;
  168.       ELSIF IsEqual (Argument, cDefinition) THEN
  169.     MakeDef := TRUE;
  170.       ELSIF IsEqual (Argument, cErrors) THEN
  171.     MakeErr := TRUE;
  172.       ELSIF IsEqual (Argument, cLong) THEN
  173.     SetReportMode (eListing);
  174.       ELSIF IsEqual (Argument, cImmediate) THEN
  175.     SetReportMode (eImmediate);
  176.       ELSIF IsEqual (Argument, cScan) THEN
  177.     MakeScan := TRUE;
  178.       ELSIF IsEqual (Argument, cParsDrv) THEN
  179.     MakeParsDrv := TRUE;
  180.       ELSIF IsEqual (Argument, cAll) THEN
  181.     MakeErr := TRUE;
  182.     MakeDef := TRUE;
  183.     MakeParsDrv := TRUE;
  184.     MakeScan := TRUE;
  185.       ELSIF IsEqual (Argument, cCase) THEN
  186.     CaseFlag := TRUE;
  187.       ELSIF IsEqual (Argument, cTest) THEN
  188.     TEST := TRUE;
  189.       ELSIF IsEqual (Argument, cVerbose) THEN
  190.     Verbose := TRUE;
  191.       ELSIF IsEqual (Argument, cLine) THEN
  192.     LineFlag := TRUE;
  193.       ELSIF IsEqual (Argument, cNoTrace) THEN
  194.     NoTrace := TRUE;
  195.       ELSIF IsEqual (Argument, cNoDefault) THEN
  196.     NoDefault := TRUE;
  197.       ELSIF IsEqual (Argument, cHelp) THEN
  198.     FileName := HelpFile;
  199.     InsertPath (FileName);
  200.     file := ReadOpen (FileName);
  201.     IF StatIsBad (file) THEN
  202.       ArrayToString (FileName, ArgString);
  203.       SysErrorMessageI (file, eError, eString, ADR (ArgString));
  204.     ELSE
  205.       CopyFile (file, StdOutput);
  206.     END;
  207.     Generate := FALSE;
  208.     RETURN;
  209.       ELSE
  210.     ArrayToString (Argument, ArgString);
  211.     ErrorMessageI (eNoOption, eError, NoPosition, eString, ADR (ArgString));
  212.       END;
  213.     END;
  214.  
  215.     IF SourceFile = StdInput THEN
  216.       FileName := ShortHelpFile;
  217.       InsertPath (FileName);
  218.       file := ReadOpen (FileName);
  219.       IF StatIsBad (file) THEN
  220.     ArrayToString (FileName, ArgString);
  221.     SysErrorMessageI (file, eError, eString, ADR (ArgString));
  222.       ELSE
  223.     CopyFile (file, StdOutput);
  224.       END;
  225.       Generate := FALSE;
  226.       RETURN;
  227.     END;
  228.   END ArgCheck;
  229.  
  230. PROCEDURE GenerateSupport;
  231.   VAR
  232.     FileName        : ARRAY [0..255] OF CHAR;
  233.     ParsDrv,
  234.     ParsDef, ParsImp,
  235.     ScanDef, ScanImp,
  236.     ErrDef,  ErrImp    : ARRAY [0..255] OF CHAR;
  237.     in, out        : tFile;
  238.     String1, String2    : tString;
  239.   BEGIN
  240.     IF Language = Modula2 THEN
  241.       ParsDrv    := ParsDrvM;
  242.       ParsDef    := ParsDefM;
  243.       ParsImp    := ParsImpM;
  244.       ScanDef    := ScanDefM;
  245.       ScanImp    := ScanImpM;
  246.       ErrDef    := ErrDefM;
  247.       ErrImp    := ErrImpM;
  248.       ExtDef    := ExtDefM;
  249.       ExtImp    := ExtImpM;
  250.     ELSE
  251.       ParsDrv    := ParsDrvC;
  252.       ParsDef    := ParsDefC;
  253.       ParsImp    := ParsImpC;
  254.       ScanDef    := ScanDefC;
  255.       ScanImp    := ScanImpC;
  256.       ErrDef    := ErrDefC;
  257.       ErrImp    := ErrImpC;
  258.       ExtDef    := ExtDefC;
  259.       ExtImp    := ExtImpC;
  260.     END;
  261.  
  262.     IF MakeScan THEN
  263.       MakeFileName (ScannerName, Scanner, ExtDef, FileName);
  264.       out := WriteOpen (FileName);    CheckWriteOpen (out, FileName);
  265.       InsertPath (ScanDef);
  266.       in := ReadOpen (ScanDef);        CheckReadOpen (in, ScanDef);
  267.       CopyFile (in, out);
  268.       WriteClose (out);
  269.       ReadClose (in);
  270.  
  271.       MakeFileName (ScannerName, Scanner, ExtImp, FileName);
  272.       out := WriteOpen (FileName);    CheckWriteOpen (out, FileName);
  273.       InsertPath (ScanImp);
  274.       in := ReadOpen (ScanImp);        CheckReadOpen (in, ScanImp);
  275.       CopyFile (in, out);
  276.       WriteClose (out);
  277.       ReadClose (in);
  278.     END;
  279.  
  280.     IF MakeErr THEN
  281.       out := WriteOpen (ErrDef);    CheckWriteOpen (out, ErrDef);
  282.       InsertPath (ErrDef);
  283.       in := ReadOpen (ErrDef);        CheckReadOpen (in, ErrDef);
  284.       CopyFile (in, out);
  285.       WriteClose (out);
  286.       ReadClose (in);
  287.  
  288.       out := WriteOpen (ErrImp);    CheckWriteOpen (out, ErrImp);
  289.       InsertPath (ErrImp);
  290.       in := ReadOpen (ErrImp);        CheckReadOpen (in, ErrImp);
  291.       CopyFile (in, out);
  292.       WriteClose (out);
  293.       ReadClose (in);
  294.     END;
  295.  
  296.     IF MakeParsDrv THEN
  297.       IF ParserName = NoIdent THEN
  298.      ArrayToString    (Parser, String1);
  299.       ELSE
  300.      GetString    (ParserName, String1);
  301.       END;
  302.       ArrayToString    (Drv, String2);
  303.       Concatenate    (String1, String2);
  304.       ArrayToString    (ExtImp, String2);
  305.       Concatenate    (String1, String2);
  306.       Append        (String1, 0C);
  307.       StringToArray    (String1, FileName);
  308.       out := WriteOpen (FileName);    CheckWriteOpen (out, FileName);
  309.       InsertPath (ParsDrv);
  310.       in := ReadOpen (ParsDrv);        CheckReadOpen (in, ParsDrv);
  311.       CopyFile (in, out);
  312.       WriteClose (out);
  313.       ReadClose (in);
  314.     END;
  315.  
  316.     InsertPath (ParsImp);
  317.     Pars := ReadOpen (ParsImp);        CheckReadOpen (Pars, ParsImp);
  318.  
  319.     IF MakeDef THEN
  320.       InsertPath (ParsDef);
  321.       Def := ReadOpen (ParsDef);    CheckReadOpen (Def, ParsDef);
  322.     ELSE
  323.       Def := ReadOpen (DevNull);    CheckReadOpen (Def, DevNull);
  324.     END;
  325.   END GenerateSupport;
  326.  
  327. PROCEDURE MakeFileName (Name: tIdent; Default, Ext: ARRAY OF CHAR; VAR FileName: ARRAY OF CHAR);
  328.    VAR String1, String2    : tString;
  329.    BEGIN
  330.       IF Name = NoIdent THEN
  331.      ArrayToString    (Default, String1);
  332.       ELSE
  333.      GetString    (Name, String1);
  334.       END;
  335.       ArrayToString    (Ext, String2);
  336.       Concatenate    (String1, String2);
  337.       Append        (String1, 0C);
  338.       StringToArray    (String1, FileName);
  339.    END MakeFileName;
  340.  
  341. PROCEDURE ExpandLine (Out: tFile; Line: tString);
  342.    VAR
  343.       Ch    : CHAR;
  344.       i        : CARDINAL;
  345.    BEGIN
  346.       i := 3;
  347.       LOOP
  348.      INC (i);
  349.      IF i > Length (Line) THEN WriteNl (Out); EXIT; END;
  350.      Ch := Char (Line, i);
  351.      CASE Ch OF
  352.      | '@' : IF ParserName = NoIdent
  353.          THEN WriteS (Out, Parser); 
  354.          ELSE WriteIdent (Out, ParserName); END;
  355.      | '$' : IF ScannerName = NoIdent THEN
  356.             IF Char (Line, i + 1) = '_'
  357.             THEN INC (i);
  358.             ELSE WriteS (Out, Scanner);
  359.             END;
  360.          ELSE WriteIdent (Out, ScannerName); END;
  361.      ELSE     WriteC (Out, Ch);
  362.      END;
  363.       END;
  364.    END ExpandLine;
  365.  
  366. PROCEDURE CopyFile (In, Out: tFile);
  367.   VAR Line    : tString;
  368.   BEGIN
  369.     WHILE NOT EndOfFile (In) DO
  370.       ReadL (In, Line);
  371.       IF (Length (Line) >= 2) AND (Char (Line, 1) = '$') AND (Char (Line, 2) = '@') THEN
  372.      ExpandLine (Out, Line);
  373.       ELSE
  374.      WriteL (Out, Line);
  375.       END;
  376.     END;
  377.   END CopyFile;
  378.  
  379. BEGIN
  380.   LineFlag    := FALSE;
  381.   TEST        := FALSE;
  382.   Generate    := TRUE;
  383. END ArgCheck.
  384.